package com.wn.wanflow.task

import android.app.Application
import android.content.Context
import com.alibaba.android.arouter.launcher.ARouter
import com.blankj.utilcode.util.AppUtils
import com.blankj.utilcode.util.LogUtils
import com.blankj.utilcode.util.PathUtils
import com.scwang.smart.refresh.footer.ClassicsFooter
import com.scwang.smart.refresh.header.ClassicsHeader
import com.scwang.smart.refresh.layout.SmartRefreshLayout
import com.tencent.mmkv.MMKV
import com.tencent.mmkv.MMKVLogLevel
import com.wn.framework.helper.AppHelper
import com.wn.framework.manager.ActivityLifecycle
import com.wn.task.task.Task
import com.wn.task.utils.DispatcherExecutor
import com.wn.wanflow.BuildConfig
import dagger.hilt.android.qualifiers.ApplicationContext
import java.util.concurrent.ExecutorService
import javax.inject.Inject
import javax.inject.Singleton

/**
 * @Author: wn
 * @Date: 2024/8/14 16:25
 * @Description: 需要被初始化的任务们 集中管理
 * run 执行 初始化 操作
 */

/**
 * 初始化应用环境
 * @property application Application
 * @constructor
 */
@Singleton
class InitAppHelperTask @Inject constructor(private val application: Application) :
  Task() {
  // 异步线程执行的Task在被调用await的时候等待
  override fun needWait(): Boolean {
    return true
  }

  /**
   * 任务真正执行的地方
   */
  override fun run() {
    AppHelper.init(application, BuildConfig.DEBUG)
  }
}

/**
 * 注册 Activity 生命周期
 * 1 APP前后台切换监听
 * 2 Activity管理类
 */
@Singleton
class InitActivityLifecycleTask @Inject constructor(private val application: Application) :
  Task() {
  // 异步线程执行的Task在被调用await的时候等待
  override fun needWait(): Boolean {
    return true
  }

  /**
   * 任务真正执行的地方
   */
  override fun run() {
    ActivityLifecycle.register(application)
  }
}

/**
 * 初始化 MMKV
 */
@Singleton
class InitMMKVTask @Inject constructor(@ApplicationContext private val context: Context) : Task() {

  // 异步线程执行的Task在被调用await的时候等待
  override fun needWait(): Boolean {
    return true
  }

  /**
   * 依赖某些任务，在某些任务完成后才能执行
   * 一般被依赖的任务初始化 context 供此处调用
   * 这里使用 hilt 无需依赖其他任务 获取 context
   */
/*
    override fun dependsOn(): MutableList<Class<out Task>> {
    val tasks = mutableListOf<Class<out Task?>>()
    tasks.add(ContextTask::class.java)
    return tasks
  }
  */

  // 指定线程池
  override fun runOn(): ExecutorService? {
    return DispatcherExecutor.iOExecutor
  }

  // 执行任务初始化
  override fun run() {
    val rootDir: String = MMKV.initialize(context, PathUtils.getInternalAppFilesPath())
    MMKV.setLogLevel(
      if (AppUtils.isAppDebug()) {
        MMKVLogLevel.LevelDebug
      } else {
        MMKVLogLevel.LevelError
      }
    )
    LogUtils.dTag("MMKV", "mmkv root: $rootDir")
  }
}

/**
 * 全局初始化SmartRefreshLayout
 */
@Singleton
class InitRefreshLayoutTask @Inject constructor() : Task() {
  // 异步线程执行的Task在被调用await的时候等待
  override fun needWait(): Boolean {
    return true
  }

  override fun run() {
    // 设置全局的Header构建器
    SmartRefreshLayout.setDefaultRefreshHeaderCreator { context, layout ->
      layout.setPrimaryColorsId(android.R.color.white)
      // 指定为经典 Header
      ClassicsHeader(context)
    }
    // 设置全局的Footer构建器
    SmartRefreshLayout.setDefaultRefreshFooterCreator { context, _ ->
      // 指定为经典 Footer，默认是 BallPulseFooter
      ClassicsFooter(context)
    }
  }
}

/**
 * 初始化 ARouter
 */
@Singleton
class InitARouterTask @Inject constructor(private val application: Application) :
  Task() {
  // 异步线程执行的Task在被调用await的时候等待
  override fun needWait(): Boolean {
    return true
  }

  //执行任务，任务真正的执行逻辑
  override fun run() {
    // 这两行必须写在init之前，否则这些配置在init过程中将无效
    if (AppUtils.isAppDebug()) {
      // 开启打印日志
      ARouter.openLog()
      // 开启调试模式(如果在InstantRun模式下运行，必须开启调试模式！线上版本需要关闭,否则有安全风险)
      ARouter.openDebug()
    }
    ARouter.init(application)
  }
}